package com.game.majiang.algorithm;

import java.util.Vector;

public class cardlogic {
	public static Vector<card> clone(Vector<card> pais)
	{
		Vector<card> temp = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			temp.addElement(pais.get(i));
		}
		return temp;
	}
	public Vector<card> findhua(Vector<card> pais)
	{
		Vector<card> rec = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value() > 100)
			{
				rec.addElement(pais.get(i));
			}
		}
		return rec;
	}
	public static boolean checkhua(card pai)
	{
		if(pai.type.get_value() > 100)
		{
			return true;
		}
		return false;
	}
	public static boolean checkchi(card pai, card pai1, card pai2, Vector<card> pais)
	{
		if(pai.type.get_value() > 100)
		{
			return false;
		}
		if(getcardcount(pai1.type.get_value(), pais) == 0)
		{
			return false;
		}
		if(getcardcount(pai2.type.get_value(), pais) == 0)
		{
			return false;
		}
		int min = pai.type.get_value();
		if(min > pai1.type.get_value())
		{
			min = pai1.type.get_value();
		}
		if(min > pai2.type.get_value())
		{
			min = pai2.type.get_value();
		}
		if(min*3+3 != (pai.type.get_value()+pai1.type.get_value()+pai2.type.get_value()))
		{
			return false;
		}
		return true;
	}
	public static groups chigroup(card pai, card pai1, card pai2, groups gro, int id)
	{
		group temp = new group();
		temp.type = grouptype.Chi;
		temp.playerid = id;
		temp.cards = new Vector<card>();
		card temppai = new card(pai.type.get_value());
		temp.cards.addElement(temppai);
		card temppai1 = new card(pai1.type.get_value());
		temp.cards.addElement(temppai1);
		card temppai2 = new card(pai2.type.get_value());
		temp.cards.addElement(temppai2);
		gro.pais.addElement(temp);
		return gro;
	}
	public static Vector<card> chi(card pai1, card pai2, Vector<card> pais)
	{
		pais = deletecard(pai1.type.get_value(), pais, 1);
		pais = deletecard(pai2.type.get_value(), pais, 1);
		return pais;
	}
	public static boolean checkpeng(card pai, Vector<card> pais)
	{
		if(getcardcount(pai.type.get_value(), pais)<2)
		{
			return false;
		}
		return true;
	}
	public static groups penggroup(card pai, groups gro, int id)
	{
		group temp = new group();
		temp.type = grouptype.Peng;
		temp.playerid = id;
		temp.cards = new Vector<card>();
		card temppai = new card(pai.type.get_value());
		temp.cards.addElement(temppai);
		card temppai1 = new card(pai.type.get_value());
		temp.cards.addElement(temppai1);
		card temppai2 = new card(pai.type.get_value());
		temp.cards.addElement(temppai2);
		gro.pais.addElement(temp);
		return gro;
	}
	public static Vector<card> peng(card pai, Vector<card> pais)
	{
		pais = deletecard(pai.type.get_value(), pais, 2);
		return pais;
	}
	public static grouptype checkgang(card pai, Vector<card> pais, groups gro)
	{
		for(int i=0;i<gro.pais.size(); i++)
		{
			if(gro.pais.get(i).type == grouptype.Peng && gro.pais.get(i).cards.get(0).type.get_value() == pai.type.get_value())
			{
				return grouptype.BianGang;
			}
		}
		int count = getcardcount(pai.type.get_value(), pais);
		if(count == 3)
		{
			return grouptype.MingGang;
		}
		else if(count == 4)
		{
			return grouptype.AnGang;
		}
		return grouptype.Null;
	}
	public static groups ganggroup(card pai, groups gro, grouptype type, int id, Vector<Integer> monyids)
	{
		if(type == grouptype.BianGang)
		{
			for(int i=0;i<gro.pais.size(); i++)
			{
				if(gro.pais.get(i).type == grouptype.Peng && gro.pais.get(i).cards.get(0).type.get_value() == pai.type.get_value())
				{
					gro.pais.get(i).type = grouptype.BianGang;
					card temppai = new card(pai.type.get_value());
					gro.pais.get(i).cards.addElement(temppai);
					gro.pais.get(i).moneyids = new Vector<Integer>(monyids);
					gro.pais.get(i).playerid = id;
				}
			}
		}
		else
		{
			group temp = new group();
			temp.type = type;
			temp.playerid = id;
			temp.cards = new Vector<card>();
			card temppai = new card(pai.type.get_value());
			temp.cards.addElement(temppai);
			card temppai1 = new card(pai.type.get_value());
			temp.cards.addElement(temppai1);
			card temppai2 = new card(pai.type.get_value());
			temp.cards.addElement(temppai2);
			card temppai3 = new card(pai.type.get_value());
			temp.cards.addElement(temppai3);
			temp.moneyids = new Vector<Integer>(monyids);
			gro.pais.addElement(temp);
		}
		return gro;
	}
	public static Vector<card> gang(card pai, Vector<card> pais, grouptype type)
	{
		if(type == grouptype.BianGang)
		{
			pais = deletecard(pai.type.get_value(), pais, 1);
		}
		else if(type == grouptype.MingGang)
		{
			pais = deletecard(pai.type.get_value(), pais, 3);
		}
		else if(type == grouptype.AnGang)
		{
			pais = deletecard(pai.type.get_value(), pais, 4);
		}
		return pais;
	}
	public static findcardtypes findchi(card pai, Vector<card> pais)
	{
		findcardtypes rec = new findcardtypes();
		if(pai.type.get_value() > 100)//花牌不能吃
		{
			return rec;
		}
		if(checkcard(pai.type.get_value(), pais) && checkcard(pai.type.get_value()+1, pais) && checkcard(pai.type.get_value()+2, pais))
		{
			findcardtype type = new findcardtype();
			type.type = checktype.Chi;
			type.cards = new Vector<card>();
			type.cards.addElement(findcard(pai.type.get_value()+1, pais));
			type.cards.addElement(findcard(pai.type.get_value()+2, pais));
			rec.findcards.addElement(type);
		}
		if(checkcard(pai.type.get_value(), pais) && checkcard(pai.type.get_value()+1, pais) && checkcard(pai.type.get_value()-1, pais))
		{
			findcardtype type = new findcardtype();
			type.type = checktype.Chi;
			type.cards = new Vector<card>();
			type.cards.addElement(findcard(pai.type.get_value()+1, pais));
			type.cards.addElement(findcard(pai.type.get_value()-1, pais));
			rec.findcards.addElement(type);
		}
		if(checkcard(pai.type.get_value(), pais) && checkcard(pai.type.get_value()-1, pais) && checkcard(pai.type.get_value()-2, pais))
		{
			findcardtype type = new findcardtype();
			type.type = checktype.Chi;
			type.cards = new Vector<card>();
			type.cards.addElement(findcard(pai.type.get_value()-1, pais));
			type.cards.addElement(findcard(pai.type.get_value()-2, pais));
			rec.findcards.addElement(type);
		}
		return rec;
	}
	public static findcardtypes findpeng(card pai, Vector<card> pais)
	{
		findcardtypes rec = new findcardtypes();
		if(getcardcount(pai.type.get_value(), pais) >= 2)
		{
			findcardtype type = new findcardtype();
			type.type = checktype.Peng;
			type.cards = new Vector<card>();
			Vector<card> temp = findcards(pai.type.get_value(), pais);
			for(int i=0; i<temp.size(); i++)
			{
				type.cards.addElement(temp.get(i));
			}
			rec.findcards.addElement(type);
		}
		return rec;
	}
	public static findcardtypes findgangan(card pai, Vector<card> pais)
	{
		findcardtypes rec = new findcardtypes();
		for(int i=0; i<pais.size(); i++)
		{
			if(getcardcount(pais.get(i).type.get_value(), pais) == 3 && pais.get(i).type.get_value() == pai.type.get_value())
			{
				findcardtype type = new findcardtype();
				type.type = checktype.Gang;
				type.cards = new Vector<card>();
				Vector<card> temp = findcards(pai.type.get_value(), pais);
				for(int j=0; j<temp.size(); j++)
				{
					type.cards.addElement(temp.get(j));
				}
				rec.findcards.addElement(type);
				break;
			}
			if(getcardcount(pais.get(i).type.get_value(), pais) == 4)
			{
				findcardtype type = new findcardtype();
				type.type = checktype.Gang;
				type.cards = new Vector<card>();
				Vector<card> temp = findcards(pai.type.get_value(), pais);
				for(int j=0; j<temp.size(); j++)
				{
					type.cards.addElement(temp.get(j));
				}
				rec.findcards.addElement(type);
				break;
			}
		}
		return rec;
	}
	public static findcardtypes findgangbian(card pai, groups gro)
	{
		findcardtypes rec = new findcardtypes();
		for(int i=0;i<gro.pais.size(); i++)
		{
			if(gro.pais.get(i).type == grouptype.Peng && gro.pais.get(i).cards.get(0).type.get_value() == pai.type.get_value())
			{
				findcardtype type = new findcardtype();
				type.type = checktype.Gang;
				type.cards = new Vector<card>();
				type.cards = addcard(pai.type.get_value(), type.cards, 4);
				rec.findcards.addElement(type);
			}
		}
		return rec;
	}
	public static findcardtypes findgang(card pai, Vector<card> pais)
	{
		findcardtypes rec = new findcardtypes();
		if(getcardcount(pai.type.get_value(), pais) == 3)
		{
			findcardtype type = new findcardtype();
			type.type = checktype.Gang;
			type.cards = new Vector<card>();
			Vector<card> temp = findcards(pai.type.get_value(), pais);
			for(int i=0; i<temp.size(); i++)
			{
				type.cards.addElement(temp.get(i));
			}
			rec.findcards.addElement(type);
		}
		return rec;
	}
	//gang 1自己杠 2别人杠 3别人杠出牌
	public static Vector<HuType> checkhu(int val, Vector<card> pais, groups cpgpais, int gang, int ming, int haidi, int zimo, int tianpai, int isyaojiu, int isjiangdui, int ismenqing, int iszhongzhang)
	{
		Vector<HuType> rectype = new Vector<HuType>();
		card temp = new card(val);
		if(temp.type.get_value() == 0)
		{
			return rectype;
		}
		Vector<card> newpais = new Vector<card>();
		Vector<card> newpais2 = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			newpais.addElement(pais.get(i));
			newpais2.addElement(pais.get(i));
		}
		if(zimo == 0)
		{
			newpais = addcard(val, newpais, 1);
			newpais2 = addcard(val, newpais2, 1);
		}
		//普通胡牌
		int qidui = checkhu_qidui(newpais);
		if(qidui == 1)//七对
		{
			rectype.addElement(HuType.QiDui);
			rectype.addElement(HuType.PiHu);
		}
		else if(qidui == 2)//龙七对
		{
			rectype.addElement(HuType.LongQiDui);
			rectype.addElement(HuType.PiHu);
		}
		else if(qidui == 3)//双龙七
		{
			rectype.addElement(HuType.ShuangLongQiDui);
			rectype.addElement(HuType.PiHu);
		}
		else if(checkhu_norm(newpais))//胡牌
		{
			rectype.addElement(HuType.PiHu);
		}
		if(rectype.size() > 0)
		{
			if(zimo == 1)
			{
				rectype.addElement(HuType.ZiMo);
				if(tianpai == 1)
				{
					rectype.addElement(HuType.tianhu);
				}
			}
			else
			{
				if(tianpai == 1)
				{
					rectype.addElement(HuType.dihu);
				}
			}
			String pp = "";
			for(int i=0; i<newpais2.size(); i++)
			{
				pp+=newpais2.get(i).type.get_name();
			}
			//胡牌
			//			int siguiyi = checkhu_siguiyi(val, newpais2, cpgpais);
			//			int sanyuan = checkhu_sanyuan(newpais2, cpgpais);
			//			if(siguiyi == 1)
			//			{
			//				rectype.addElement(HuType.MingSiGuiYi);
			//			}
			//			else if(siguiyi == 2)
			//			{
			//				rectype.addElement(HuType.AnSiGuiYi);
			//			}
			//			if(sanyuan == 1)
			//			{
			//				rectype.addElement(HuType.XiaoSanYuan);
			//			}
			//			else if(sanyuan == 2)
			//			{
			//				rectype.addElement(HuType.DaSanYuan);
			//			}
			if(checkhu_duiduihu(newpais2, cpgpais))
			{
				rectype.addElement(HuType.PengPnegHu);
				if(checkjiangdui(newpais2, cpgpais) && isjiangdui == 1)
				{
					rectype.addElement(HuType.Jangdui);
				}
			}
			if(gang == 1)
			{
				rectype.addElement(HuType.GangShangKaiHua);
			}
			else if(gang == 2)
			{
				rectype.addElement(HuType.QiangGangHu);
			}
			else if(gang == 3)
			{
				rectype.addElement(HuType.GangShangPao);
			}
			if(ming == 1)
			{
				rectype.addElement(HuType.LiangDao);
			}
			if(haidi == 1)
			{
				rectype.addElement(HuType.HaiDiLao);
			}
//			if(val==5||val==15||val==25)
//			{
//				rectype.addElement(HuType.KaWuXing);
//			}
			if(pais.size() == 1 || pais.size() == 2)
			{
				rectype.addElement(HuType.ShouZhuaYi);
			}
			if(checkhu_qingyise(newpais2, cpgpais))
			{
				rectype.addElement(HuType.QingYiSe);
			}
			if(checkyaojiu(newpais2, cpgpais) && isyaojiu == 1)
			{
				rectype.addElement(HuType.Yaojiu);
			}
			if(checkmenqing(cpgpais) && ismenqing == 1)
			{
				rectype.addElement(HuType.Menqing);
			}
			if(checkzhongzhang(newpais2, cpgpais) && iszhongzhang == 1)
			{
				rectype.addElement(HuType.Zhongzhang);
			}
		}
		return rectype;
	}
	public static boolean checkhu_qingyise(Vector<card> pais, groups cpgpais)
	{
		boolean ret = true;
		int val = pais.get(0).type.get_value();
		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			if(cpgpais.pais.get(i).cards.get(0).type.get_value()/10 != val/10)
			{
				ret = false;
			}
		}
		//int count2 = 0;
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value()/10 != val/10)
			{
				ret = false;
			}
		}
		return ret;
	}
	public static boolean checkdingque(int hua, Vector<card> pais)
	{
		boolean ret = true;
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value()/10 == hua)
			{
				ret = false;
			}
		}
		return ret;
	}
	public static int checkhu_sanyuan(Vector<card> pais, groups cpgpais)
	{
		int zhong = 0;
		int fa = 0;
		int bai = 0;
		int ret = 0;
		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			if(cpgpais.pais.get(i).type != grouptype.Chi)
			{
				if(cpgpais.pais.get(i).cards.get(0).type.get_value() == carddata.Hongzhong.get_value())
				{
					zhong = 2;
				}
				if(cpgpais.pais.get(i).cards.get(0).type.get_value() == carddata.Facai.get_value())
				{
					fa = 2;
				}
				if(cpgpais.pais.get(i).cards.get(0).type.get_value() == carddata.Baiban.get_value())
				{
					bai = 2;
				}
			}
		}
		if(zhong==0)
		{
			int count = getcardcount(carddata.Hongzhong.get_value(), pais);
			if(count == 2)
			{
				zhong = 1;
			}
			else if(count > 2)
			{
				zhong = 2;
			}
		}
		if(fa==0)
		{
			int count = getcardcount(carddata.Facai.get_value(), pais);
			if(count == 2)
			{
				fa = 1;
			}
			else if(count > 2)
			{
				fa = 2;
			}
		}
		if(bai==0)
		{
			int count = getcardcount(carddata.Baiban.get_value(), pais);
			if(count == 2)
			{
				bai = 1;
			}
			else if(count > 2)
			{
				bai = 2;
			}
		}
		if(zhong == 2 && fa == 2 && bai == 2)
		{
			ret = 2;
		}
		else if(zhong != 0 && fa != 0 && bai != 0)
		{
			ret = 1;
		}
		return ret;
	}
	public static int checkhu_siguiyi(int val, Vector<card> pais, groups cpgpais)
	{
		int ret = 0;
		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			if(cpgpais.pais.get(i).type.get_value() == grouptype.Peng.get_value() && cpgpais.pais.get(i).cards.get(0).type.get_value() == val)
			{
				ret = 1;
			}
		}
		int count = getcardcount(val, pais);
		if(count == 4)
		{
			ret = 2;
		}
		return ret;
	}
	public static boolean checkhu_duiduihu(Vector<card> pais, groups cpgpais)
	{
		boolean ret = true;
		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			if(cpgpais.pais.get(i).type.get_value() == grouptype.Chi.get_value())
			{
				ret = false;
			}
		}
		int count2 = 0;
		for(int i=0; i<pais.size(); i++)
		{
			int count = getcardcount(pais.get(i).type.get_value(), pais);
			if(count == 1)
			{
				ret = false;
			}
			else if(count == 2)
			{
				count2++;
			}
			else if(count == 4)
			{
				ret = false;
			}
		}
		if(count2 > 2)
		{
			ret = false;
		}
		return ret;
	}
	public static int checkhu_qidui(Vector<card> pais)
	{
	Vector<Integer> temps = new Vector<>();
		boolean ret = true;
		if(pais.size() != 14)
		{
			return 0;
		}
		int longcount = 0;
		for(int i=0; i<pais.size(); i++)
		{
			int count = getcardcount(pais.get(i).type.get_value(), pais);
			if(count == 2)
			{

			}
			else if(count == 4)
			{
				boolean fl = false;
				for(int j=0; j<temps.size(); j++)
				{
					if(temps.get(j) == pais.get(i).type.get_value())
					{
						fl = true;
					}
				}
				if(!fl)
				{
					temps.addElement(pais.get(i).type.get_value());
					longcount++;
				}
			}
			else
			{
				ret = false;
			}
		}
		if(ret)
		{
			if(longcount == 0)
			{
				return 1;
			}
			else if(longcount == 1)
			{
				return 2;
			}
			else
			{
				return 3;
			}
		}
		else
		{
			return 0;
		}
	}
	public static boolean checkyaojiu(Vector<card> pais, groups cpgpais)
	{
		boolean ret = true;

		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			boolean isyaojiu = false;
			for(int j=0; j<cpgpais.pais.get(i).cards.size(); j++)
			{
				if(cpgpais.pais.get(i).cards.get(j).type.get_value()==1
						||cpgpais.pais.get(i).cards.get(j).type.get_value()==11
						||cpgpais.pais.get(i).cards.get(j).type.get_value()==21
						||cpgpais.pais.get(i).cards.get(j).type.get_value()==9
						||cpgpais.pais.get(i).cards.get(j).type.get_value()==19
						||cpgpais.pais.get(i).cards.get(j).type.get_value()==29)
				{
					isyaojiu = true;
				}
			}
			if(isyaojiu == false)
			{
				ret = false;
				return ret;
			}
		}
		for(int i=0; i<pais.size(); i++)
		{
			int val = pais.get(i).type.get_value();
			if((val > 3 && val<7)||(val > 13 && val<17)||(val > 23 && val<27)||(val > 30))
			{
				ret = false;
				return ret;
			}
			if(val == 2||val == 12||val == 22)
			{
				if((getcardcount(val, pais) != getcardcount(val-1, pais)&&getcardcount(val, pais)+3 != getcardcount(val-1, pais)&&getcardcount(val, pais)+2 != getcardcount(val-1, pais))
						||getcardcount(val, pais) != getcardcount(val+1, pais))
				{
					ret = false;
					return ret;
				}
			}
			if(val == 8||val == 18||val == 28)
			{
				if((getcardcount(val, pais) != getcardcount(val+1, pais)&&getcardcount(val, pais)+3 != getcardcount(val+1, pais)&&getcardcount(val, pais)+2 != getcardcount(val+1, pais))
						||getcardcount(val, pais) != getcardcount(val-1, pais))
				{
					ret = false;
					return ret;
				}
			}
			if(val == 3||val == 13||val == 23)
			{
				if((getcardcount(val, pais) != getcardcount(val-2, pais)&&getcardcount(val, pais)+3 != getcardcount(val-2, pais)&&getcardcount(val, pais)+2 != getcardcount(val-2, pais))
						||getcardcount(val, pais) != getcardcount(val-1, pais))
				{
					ret = false;
					return ret;
				}
			}
			if(val == 7||val == 17||val == 27)
			{
				if((getcardcount(val, pais) != getcardcount(val+2, pais)&&getcardcount(val, pais)+3 != getcardcount(val+2, pais)&&getcardcount(val, pais)+2 != getcardcount(val+2, pais))
						||getcardcount(val, pais) != getcardcount(val+1, pais))
				{
					ret = false;
					return ret;
				}
			}
		}

		return ret;
	}
	public static boolean checkjiangdui(Vector<card> pais, groups cpgpais)
	{
		boolean ret = true;

		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			for(int j=0; j<cpgpais.pais.get(i).cards.size(); j++)
			{
				int val = cpgpais.pais.get(i).cards.get(j).type.get_value();
				if(val!=2
						&&val!=12
						&&val!=22
						&&val!=5
						&&val!=15
						&&val!=25
						&&val!=8
						&&val!=18
						&&val!=28)
				{
					ret = false;
					return ret;
				}
			}
		}
		for(int i=0; i<pais.size(); i++)
		{
			int val = pais.get(i).type.get_value();
			if(val!=2
					&&val!=12
					&&val!=22
					&&val!=5
					&&val!=15
					&&val!=25
					&&val!=8
					&&val!=18
					&&val!=28)
			{
				ret = false;
				return ret;
			}
		}
		return ret;
	}
	public static boolean checkmenqing(groups cpgpais)
	{
		boolean ret = true;

		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			if(cpgpais.pais.get(i).type.get_value() != grouptype.AnGang.get_value())
			{
				ret = false;
				return ret;
			}
		}

		return ret;
	}
	public static boolean checkzhongzhang(Vector<card> pais, groups cpgpais)
	{
		boolean ret = true;
		for(int i=0; i<pais.size(); i++)
		{
			int val = pais.get(i).type.get_value();
			if(val==1
					||val==11
					||val==21
					||val==9
					||val==19
					||val==29)
			{
				ret = false;
				return ret;
			}
		}
		for(int i=0; i<cpgpais.pais.size(); i++)
		{
			for(int j=0; j<cpgpais.pais.get(i).cards.size(); j++)
			{
				int val = cpgpais.pais.get(i).cards.get(j).type.get_value();
				if(val==1
						||val==11
						||val==21
						||val==9
						||val==19
						||val==29)
				{
					ret = false;
					return ret;
				}
			}
		}
		return ret;
	}
	public static boolean checkhu_norm(Vector<card> pais)
	{
		Vector<card> oldpais = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			oldpais.addElement(pais.get(i));
		}
		boolean ret = false;
		//先把将牌取出来
		for(int i=0; i<pais.size(); i++)
		{
			int allcount = pais.size();
			int count = getcardcount(pais.get(i).type.get_value(), pais);
			if(count == 2)
			{
				if(Cancutpair_2(pais.get(i).type.get_value(), pais))
				{
					//直接剔除
					int temppoint = pais.get(i).type.get_value();
					pais = deletecard(temppoint, pais, 2);
					ret = CanHuPai_3N_recursive(pais,allcount-2,1);
					pais.clear();
					for(int k=0; k<oldpais.size(); k++)
					{
						pais.addElement(oldpais.get(k));
					}
					return ret;
				}
				else
				{
					int temppoint = pais.get(i).type.get_value();
					pais = deletecard(temppoint, pais, 2);
					ret = CanHuPai_3N_recursive(pais,allcount-2,1);
					pais.clear();
					for(int k=0; k<oldpais.size(); k++)
					{
						pais.addElement(oldpais.get(k));
					}
					if(ret)              //如果满足可以返回，不满足还需要尝试其他的对子
					{
						return ret;
					}
				}
			}
			else if(count == 3)
			{
				if (Cancutpair_3(pais.get(i).type.get_value(), pais))
				{
					int temppoint = pais.get(i).type.get_value();
					pais = deletecard(temppoint, pais, 2);
					ret = CanHuPai_3N_recursive(pais,allcount-2,1);
					pais.clear();
					for(int k=0; k<oldpais.size(); k++)
					{
						pais.addElement(oldpais.get(k));
					}
					if(ret)
					{
						return ret;
					}
				}
			}
			else if(count == 4)
			{
				if (Cancutpair_4(pais.get(i).type.get_value(), pais))
				{
					int temppoint = pais.get(i).type.get_value();
					pais = deletecard(temppoint, pais, 2);
					ret = CanHuPai_3N_recursive(pais,allcount-2,1);
					pais.clear();
					for(int k=0; k<oldpais.size(); k++)
					{
						pais.addElement(oldpais.get(k));
					}
					if(ret)
					{
						return ret;
					}
				}
			}
		}
		return ret;
	}
	public static boolean CanHuPai_3N_recursive(Vector<card> arr, int count, int P)
	{
		int countp = getcardcount(P, arr);
		int countp1 = getcardcount(P+1, arr);
		int countp2 = getcardcount(P+2, arr);
		boolean ret=false;
		if(count==0)
		{
			return true;
		}

		if(P>30)        // 风牌只能组成碰
		{
			if(countp==3)
			{
				ret=CanHuPai_3N_recursive(arr,count-3,P+1);
				return  ret;
			}
			else if(countp==0)
			{
				ret=CanHuPai_3N_recursive(arr,count,P+1);
				return  ret;
			}
			else
			{
				return false;
			}

		}

		if(countp==0){                                                //如果没有该牌，直接跳过进行下一张
			ret=CanHuPai_3N_recursive(arr,count,P+1);
		}
		if(countp==1){
			if(P==8||P==18||P==28||P==9||P==19||P==29)                            //如果该牌是八或者九，则无法组合顺，不能胡
			{
				return false;
			}
			else if(countp1>0&&countp2>0)                         //能组合成顺
			{
				arr = deletecard(P, arr, 1);
				arr = deletecard(P+1, arr, 1);
				arr = deletecard(P+2, arr, 1);
				ret=CanHuPai_3N_recursive(arr,count-3,P+1);
				arr = addcard(P, arr, 1);
				arr = addcard(P+1, arr, 1);
				arr = addcard(P+2, arr, 1);
			}
			else                                                    //无法组合顺，不能胡
			{
				return false;
			}
		}
		if(countp==2){                                              //与1同理，组成两对顺
			if(P%10>7)
			{
				return false;
			}
			else if(countp1>1&&countp2>1)
			{
				arr = deletecard(P, arr, 2);
				arr = deletecard(P+1, arr, 2);
				arr = deletecard(P+2, arr, 2);
				ret=CanHuPai_3N_recursive(arr,count-6,P+1);
				arr = addcard(P, arr, 2);
				arr = addcard(P+1, arr, 2);
				arr = addcard(P+2, arr, 2);
			}
			else
			{
				return false;
			}
		}
		if(countp==3){

			arr = deletecard(P, arr, 3);
			ret=CanHuPai_3N_recursive(arr,count-3,P+1);             //当前需求 三对顺等同于三对碰

			//            if(P%10>6)
			//            {
			//                ret=CanHuPai_3N_recursive(arr,count-3,P+1);
			//            }
			//            else if(countp1>2&&countp2>2)
			//            {
			//            	arr = deletecard(P, arr, 3);
			//            	arr = deletecard(P+1, arr, 3);
			//            	arr = deletecard(P+2, arr, 3);
			//                ret=CanHuPai_3N_recursive(arr,count-9,P+1);
			//                arr = addcard(P, arr, 3);
			//                arr = addcard(P+1, arr, 3);
			//                arr = addcard(P+2, arr, 3);
			//                if(!ret)
			//                {
			//                    arr = addcard(P+1, arr, 3);
			//                    arr = addcard(P+2, arr, 3);
			//                    ret=CanHuPai_3N_recursive(arr,count-3,P+1);
			//                	arr = deletecard(P+1, arr, 3);
			//                	arr = deletecard(P+2, arr, 3);
			//                }
			//            }
			//            else
			//            {
			//                ret=CanHuPai_3N_recursive(arr,count-3,P+1);
			//            }

		}
		if(countp==4)
		{                                       //如果为四张，则至少有一张与后面组成为顺，剩下的递归，P不变
			if(P%10>7)
			{
				return false;
			}
			else if (countp1 > 0 && countp2 > 0) 
			{
				arr = deletecard(P, arr, 1);
				arr = deletecard(P+1, arr, 1);
				arr = deletecard(P+2, arr, 1);
				ret = CanHuPai_3N_recursive(arr, count - 3, P );
				arr = addcard(P, arr, 1);
				arr = addcard(P+1, arr, 1);
				arr = addcard(P+2, arr, 1);
			}
			else
			{
				return false;
			}
		}
		return ret;
	}
	public static boolean Cancutpair_2(int val, Vector<card> pais)
	{
		int c1 = getcardcount(val-2, pais);
		int c2 = getcardcount(val-1, pais);
		int c3 = getcardcount(val+1, pais);
		int c4 = getcardcount(val+2, pais);
		if(val>30)    //如果为风牌则直接可以剔除对子
		{
			return true;                      //true为可以直接剔除，false为还需回溯
		}

		else if(val==1||val==11||val==21)         //一万 一饼 一条
		{
			if(c3>=2&&c4>=2) //如果对应的二与三都大等于2
			{
				return false;
			}
			else
			{
				return true;
			}
		}

		else if(val==9||val==19||val==29)         //九万 九饼 九条
		{
			if(c2>=2&&c1>=2) //如果对应的七与八都大等于2
			{
				return false;
			}
			else
			{
				return true;
			}
		}

		else if(val==2||val==12||val==22)         //二万 二饼 二条
		{
			if(c2+c3+c4>=4&&c3>=2)  //如果一+三+四大于4且三大于2
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		else if(val==8||val==18||val==28)         //八万 八饼 八条
		{
			if(c2+c3+c1>=4&&c2>=2)  //如果九+七+六大于4且七大于2
			{
				return false;
			}
			else
			{
				return true;
			}
		}

		else if(c2+c3+c1+c4>=4)   //如果相邻的两端大于四张牌
		{
			return false;
		}
		else
		{
			return true;
		}
	}
	public static boolean Cancutpair_3(int val, Vector<card> pais)
	{
		int c1 = getcardcount(val-2, pais);
		int c2 = getcardcount(val-1, pais);
		int c3 = getcardcount(val+1, pais);
		int c4 = getcardcount(val+2, pais);
		if(val>30)    //如果为风牌则直接可以剔除对子
		{
			return false;                      //true为可以直接剔除，false为还需回溯
		}

		else if(val==1||val==11||val==21)         //一万 一饼 一条
		{
			if(c3>=1&&c4>=1) //如果对应的二与三都大等于1
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		else if(val==9||val==19||val==29)         //九万 九饼 九条
		{
			if(c2>=1&&c1>=1) //如果对应的七与八都大等于1
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		else if(val==2||val==12||val==22)         //二万 二饼 二条
		{
			if(c2+c4>=1&&c3>=1)  //如果一+四大等于1且三大等于1
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else if(val==8||val==18||val==28)         //八万 八饼 八条
		{
			if(c3+c1>=1&&c2>=1)  //如果九+六大等于1且七大等于1
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		else if(c2+c3+c1+c4>=2)   //如果相邻的两端大于两张牌
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public static boolean Cancutpair_4(int val, Vector<card> pais)
	{
		int c1 = getcardcount(val-2, pais);
		int c2 = getcardcount(val-1, pais);
		int c3 = getcardcount(val+1, pais);
		int c4 = getcardcount(val+2, pais);
		if(val>30)    //如果为风牌则直接可以剔除对子
		{
			return false;                      //true为可以直接剔除，false为还需回溯
		}

		else if(val==1||val==11||val==21)         //一万 一饼 一条
		{
			if(c3>=2&&c4>=2) //如果对应的二与三都大等于2
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		else if(val==9||val==19||val==29)         //九万 九饼 九条
		{
			if(c2>=2&&c1>=2) //如果对应的七与八都大等于2
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		else if(val==2||val==12||val==22)         //二万 二饼 二条
		{
			if(c2+c4>=2&&c3>=2)  //如果一+四大等于2且三大等于2
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else if(val==8||val==18||val==28)         //八万 八饼 八条
		{
			if(c1+c3>=2&&c2>=2)  //如果六+九大等于2且七大等于2
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		else if(c2+c3+c1+c4>=4)   //如果相邻的两端大等于4
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public static Vector<card> gethuan(int hua, Vector<card> pais, int count)
	{
		int index=0;
		Vector<card> rec = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value()/10 != hua)
			{
				index++;
				rec.addElement(pais.get(i));
				if(index == count)
				{
					return rec;
				}
			}
		}
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value()/10 == hua)
			{
				index++;
				rec.addElement(pais.get(i));
				if(index == count)
				{
					return rec;
				}
			}
		}
		return rec;
	}
	public static Vector<card> addcard(int val, Vector<card> pais, int count)
	{
		Vector<card> rec = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			rec.add(i, pais.get(i));
		}
		for(int k=0; k<count; k++)
		{
			card temp = new card(val);
			int index = 0;
			for(int j=0; j<rec.size(); j++)
			{
				if(temp.type.get_value() > rec.get(j).type.get_value())
				{
					index = j+1;
				}
			}
			rec.add(index, temp);
		}
		return rec;
	}
	public static Vector<card> deletecard(int val, Vector<card> pais, int count)
	{
		for(int k=0; k<count; k++)
		{
			for(int i=0; i<pais.size(); i++)
			{
				if(pais.get(i).type.get_value() == val)
				{
					pais.remove(i);
					break;
				}
			}
		}
		return pais;
	}
	public static boolean checkcard(int val, Vector<card> pais)
	{
		boolean flag = false;
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value() == val)
			{
				flag = true;
				break;
			}
		}
		return flag;
	}
	public static Vector<card> findcards(int val, Vector<card> pais)
	{
		Vector<card> rec = new Vector<card>();
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value() == val)
			{
				rec.addElement(pais.get(i));
			}
		}
		return rec;
	}
	public static card findcard(int val, Vector<card> pais)
	{
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value() == val)
			{
				return pais.get(i);
			}
		}
		return null;
	}
	public static int getcardcount(int val, Vector<card> pais)
	{
		int flag = 0;
		for(int i=0; i<pais.size(); i++)
		{
			if(pais.get(i).type.get_value() == val)
			{
				flag++;
			}
		}
		return flag;
	}
}
